01背包遗传算法C++实现

最新推荐文章于 2022-05-19 18:25:13 发布
最新推荐文章于 2022-05-19 18:25:13 发布
阅读量1.6k 收藏 17
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011630575/article/details/70319807
版权

算法详解： http://blog.csdn.net/u011630575/article/details/70317251

一、代码如下：

#include <windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>


/*数据集一**********************************************************************
#define  S				5			//种群的规模
#define  Pc				0.8			//交叉概率
#define  Pm				0.05			//突变概率
#define  KW             1000			//背包最大载重1000
#define  N              30			//物体总数
#define	 T				800			//最大换代数
#define	 ALIKE	        0.05			//判定相似度
int		 stop=0;						//初始化函数中初始化为所有价值之和
int		 t=0;						//目前的代数
int value[]={
220,208,198,192,180,180,165,162,160,158,155,130,125,122,120,118,115,110,105,101,100,100,98,96,95,90,88,82,80,77,75,73,72,70,69,66,65,63,60,58,56,50,30,20,15,10,8,5,3,1};
int weight[]={
80,82,85,70,72,70,66,50,55,25,50,55,40,48,50,32,22,60,30,32,40,38,35,32,25,28,30,22,25,30,45,30,60,50,20,65,20,25,30,10,20,25,15,10,10,10,4,4,2,1};


/*数据集二***********************************************************************/ 
#define  S				5			//种群的规模
#define  Pc				0.8			//交叉概率
#define  Pm				0.05			//突变概率
#define  KW             1000			//背包最大载重1000
#define  N              50			//物体总数
#define	 T				800			//最大换代数
#define	 ALIKE	        0.05			//判定相似度
int		 stop=0;						//初始化函数中初始化为所有价值之和
int		 t=0;						//目前的代数
int value[]={
220,208,198,192,180,180,165,162,160,158,155,130,125,122,120,118,115,110,105,101,100,100,98,96,95,90,88,82,80,77,75,73,72,70,69,66,65,63,60,58,56,50,30,20,15,10,8,5,3,1};
int weight[]={
80,82,85,70,72,70,66,50,55,25,50,55,40,48,50,32,22,60,30,32,40,38,35,32,25,28,30,22,25,30,45,30,60,50,20,65,20,25,30,10,20,25,15,10,10,10,4,4,2,1};

/*数据集三***********************************************************************
#define  S				5			//种群的规模
#define  Pc				0.8			//交叉概率
#define  Pm				0.05			//突变概率
#define  KW             1000			//背包最大载重1000
#define  N              60		//物体总数
#define	 T				800			//最大换代数
#define	 ALIKE	        0.05			//判定相似度
int		 stop=0;						//初始化函数中初始化为所有价值之和
int		 t=0;						//目前的代数
int value[]={
597,596,593,586,581,568,567,560,549,548,547,529,529,527,520,491,482,478,475,475,466,462,459,458,454,451,449,443,442,421,410,409,395,394,390,377,375,366,361,347,334,322,315,313,311,309,296,295,294,289,285,279,277,276,272,248,246,245,238,237,232,231,230,225,192,184,183,176,171,169,165,165,154,153,150,149,147,143,140,138,134,132,127,124,123,114,111,104,89,74,63,62,58,55,48,27,22,12,6,250};
int weight[]={
54,183,106,82,30,58,71,166,117,190,90,191,205,128,110,89,63,6,140,86,30,91,156,31,70,199,142,98,178,16,140,31,24,197,101,73,16,73,2,159,71,102,144,151,27,131,209,164,177,177,129,146,17,53,64,146,43,170,180,171,130,183,5,113,207,57,13,163,20,63,12,24,9,42,6,109,170,108,46,69,43,175,81,5,34,146,148,114,160,174,156,82,47,126,102,83,58,34,21,14};
/************************************************************************/

struct individual				//个体结构体
{
	bool chromsome[N];		//染色体编码
	double fitness;				//适应度//即本问题中的个体所得价值
	double weight;			//总重量
};
int best=0;
int same=0;
individual X[S],Y[S],bestindividual;

/************************************************************************/
int  comp(individual bestindividual,individual temp);	//比较函数
void checkalike(void);							//检查相似度函数
void GenerateInitialPopulation(void); 				//初始种群
void CalculateFitnessValue(void);					//适应度
void SelectionOperator(void);						//选择
void CrossoverOperator(void);					//交叉
void MutationOperator(void);					//变异
void FindBestandWorstIndividual(void);				//寻找最优解
void srand(unsigned int seed);					//随机生成
/************************************************************************/


int comp(individual bestindividual,individual temp)//比较函数
{
	int fit=0,w=0;//第一种不变:操作后不满足重量函数，第二种:操作后适应度小于操作前
	for(int i=0;i<N;i++){
    	fit+=temp.chromsome[i]*value[i];
	    w+=temp.chromsome[i]*weight[i];
	}
	if(w>KW)return -1;
	return (bestindividual.fitness>fit?-1:1);//如果小于原来值或者不满足重量函数，则返回-1
}

/************************************************************************/
void Checkalike(void)
{
	int i=0,j=0;
	for( i=0;i<S;i++)//相似度校验
	{
		for(j=0;j<N;j++)
		{
			bool temp=X[i].chromsome[j];
			for(int k=1;k<S;k++)
			{
				if(temp!=X[k].chromsome[j])
					break;
			}
		}
		if(j==N)
		   same++;
	}
	if(same>N*ALIKE)//大于ALIKE作为判定为早熟
	{
		int minindex=0;
		for(int n=0;n<S;n++)
		  if(X[n].fitness<X[minindex].fitness)
		       minindex=n;//确定最小
		for (j=0; j<N;j++)//重新生成
		{
			bool m=(rand()%10<5)?0:1;
			X[minindex].chromsome[j]=m;
			X[minindex].weight+=m*weight[j];//个体的总重量
			X[minindex].fitness+=m*value[j]; //个体的总价值
		}
	
	}
}

/************************************************************************/
void GenerateInitialPopulation(void)//初始种群,保证每个值都在符合条件的解
{
	int i=0,j=0; bool k;
	for(i=0;i<N;i++)stop+=value[i];//设置理论最优值
	for (i=0; i<S; i++)
	{
		int w=0,v=0;
		for (j=0; j<N;j++)
		{
			k=(rand()%10<5)?0:1;
			X[i].chromsome[j]=k;
			w+=k*weight[j];//个体的总重量
			v+=k*value[j]; //个体的总价值
		}
		if(w>KW) i--;	   //如果不是解，重新生成
		else
		{
			X[i].fitness=v;
			X[i].weight=w;
			if(v==stop)
            { 
			    bestindividual=X[i];
				return;
			}//这种情况一般不会发生
		}
	}
}
/************************************************************************/

void CalculateFitnessValue()
{
	int i=0,j=0;   	
	for (i=0; i<S; i++)
	{
		int w=0,v=0;
		for (j=0; j<N;j++)
		{
			w+=X[i].chromsome[j]*weight[j];//个体的总重量
			v+=X[i].chromsome[j]*value[j]; //个体的总价值
		}
		X[i].fitness=v;
		X[i].weight=w;
		if(v==stop)
		{
		    bestindividual=X[i];
			return;
		}//符合条件情况下最优解这种情况一般不会发生
		if(w>KW) X[i]=bestindividual;//如果不是解，找最好的一个解代之
	}
}
/************************************************************************/


void SelectionOperator(void)
{
	int i, index;
	double p, sum=0.0;
	double cfitness[S];//选择、累积概率
	individual newX[S];
	for (i=0;i<S;i++) 
	    sum+=X[i].fitness;//适应度求和
	    
	for (i=0;i<S; i++) 
	    cfitness[i]=X[i].fitness/sum; //选择概率
	    
	for (i=1;i<S; i++) 
	    cfitness[i]=cfitness[i-1]+cfitness[i];//累积概率
	    
	for (i=0;i<S;i++)
	{
		p=(rand()%1001)/1000.0;//产生一个[0,1]之间的随机数
		index=0;
		while(p>cfitness[index])//轮盘赌进行选择
		{
			index++;
		}
		newX[i]=X[index];
	}
	for (i=0; i<S; i++) 
	   X[i]=newX[i];//新的种群
}

/************************************************************************/
void CrossoverOperator(void)//交叉操作
{
	int i=0, j=0,k=0;individual temp;	
	for(i=0; i<S; i++)
	{
		int p=0,q=0;
		do
		{
			p=rand()%S;//产生两个[0，S]的随机数
			q=rand()%S;
		}while(p==q);
		int w=1+rand()%N;//[1,N]表示交换的位数
		double r=(rand()%1001)/1000.0;//[0,1]
		if(r<=Pc)
		{
			for(j=0;j<w;j++)
			{
				temp.chromsome[j]=X[p].chromsome[j];//将要交换的位先放入临时空间
				X[p].chromsome[j]=X[q].chromsome[j];
				X[q].chromsome[j]=temp.chromsome[j];
			}
		}
		if(p==best)
			if(-1==comp(bestindividual,X[p]))//如果变异后适应度变小
				X[p]=bestindividual;
				
		if(q==best)
			if(-1==comp(bestindividual,X[q]))//如果变异后适应度变小
				X[q]=bestindividual;
	}
}
/************************************************************************/


void MutationOperator(void)
{
	int i=0, j=0,k=0,q=0;
	double p=0;
	for (i=0; i<S; i++) 
	{
		for (j=0; j<N; j++) 
		{
			p=(rand()%1001)/1000.0;
			if (p<Pm)//对每一位都要考虑
			{  
				if(X[i].chromsome[j]==1)X[i].chromsome[j]=0;
				else	X[i].chromsome[j]=1;
			}
		}
		if(i==best)
			if(-1==comp(bestindividual,X[i]))//如果变异后适应度变小
				X[i]=bestindividual;
	}
}
/************************************************************************/

void FindBestandWorstIndividual(void)
{
	int i;
	bestindividual=X[0];
	for (i=1;i<S; i++)
	{
		if (X[i].fitness>bestindividual.fitness)
		{
			bestindividual=X[i];
			best=i;
		}
	}
}


/*主函数*****************************************************************/
int main()
{ 
  DWORD start, stop;
  start = GetTickCount();//程序开始时间 
  

  srand((unsigned)time(0));
  t=0;
  GenerateInitialPopulation(); //初始群体包括产生个体和计算个体的初始值
  while (t<=T) 
  {	
		FindBestandWorstIndividual();	//保存当前最优解
		SelectionOperator();			//选择	  	
		CrossoverOperator();			//交叉	  
		MutationOperator();			   //变异
		Checkalike();				  //检查相似度
		CalculateFitnessValue();	 //计算新种群适应度
		t++;
  }	
  FindBestandWorstIndividual();			//找到最优解
  
  printf(" 物品价值：");
  for(int k=0;k<N;k++)
  {
      printf(" %d ",value[k]);
  }
   printf("\n");
   printf(" 物品重量:");
   for(int k=0;k<N;k++)
   { 
     printf(" %d  ",weight[k]);
   }
   printf("\n");
   printf("背包容量 %d\n",1000);   	//输出最优值
   printf("-----------------------------\n"); 
  
  
  printf("最优值 %f\n",bestindividual.fitness);   	//输出最优值
  printf("对应重量 %f\n",bestindividual.weight);       //对应重量
  
  printf("线性解：");
  for(int k=0;k<N;k++)
  {
     if(bestindividual.chromsome[k]==1){  //输出最优解
     	 printf(" %d ",1);
     }else{
     	 printf(" %d ",0);
     }
  }
  printf("\n");
  printf("\n");

  stop = GetTickCount();//程序结束时间 
  printf("运行时间: %lld ms\n", stop - start);
  
  system("pause");
  return 0;
} 
/*结束***********************************************************************/

二 、结果分析

     蓝色字表示   输出结果

     运行时间表示 算法复杂度

 1)数据集一:物体总个数为30时

 物品价值： 220  208  198  192  180  180  165  162  160  158  155  130  125  122  120  118  115  110  105  101  100  100  98  96  95  90  88  82  80  77

 物品重量: 80   82   85   70   72   70   66   50   55   25   50   55   40   48   50   32   22   60   30   32   40   38   35   32   25   28   30   22   25   30

背包容量 1000

-----------------------------

最优值 2984.000000

对应重量 995.000000

线性解： 1  1  0  1  1  1  0  1  1  1  1  1  1  1  0  1  1  0  1  1  1  1  0  1  1  0  0  1  1  0

运行时间: 16 ms

 

 2)数据集二:物体总个数为50时

物品价值： 220  208  198  192  180  180  165  162  160  158  155  130  125  122  120  118  115  110  105  101  100  100  98  96  95  90  88  82  80  77  75  73  72  70  69  66  65  63  60  58  56  50  30  20  15  10  8  5  3  1

 物品重量: 80   82   85   70   72   70   66   50   55   25   50   55   40   48   50   32   22   60   30   32   40   38   35   32   25   28   30   22   25   30   45   30   60   50   20   65   20   25   30   10   20   25   15   10   10   10   4   4   2   1

背包容量 1000

-----------------------------

最优值 3010.000000

对应重量 993.000000

线性解： 1  0  0  1  1  1  0  1  0  1  1  1  1  1  0  1  1  1  1  1  0  0  1  1  1  1  1  1  1  0  0  0  0  0  1  0  1  0  0  1  0  0  0  0  0  0  1  1  1  0

 

运行时间: 31 ms

 

 3)数据集三:物体总个数为60时

物品价值： 597  596  593  586  581  568  567  560  549  548  547  529  529  527  520  491  482  478  475  475  466  462  459  458  454  451  449  443  442  421  410  409  395  394  390  377  375  366  361  347  334  322  315  313  311  309  296  295  294  289  285  279  277  276  272  248  246  245  238  237

 物品重量: 54   183   106   82   30   58   71   166   117   190   90   191   205   128   110   89   63   6   140   86   30   91   156   31   70   199   142   98   178   16   140   31   24   197   101   73   16   73   2   159   71   102   144   151   27   131   209   164   177   177   129   146   17   53   64   146   43   170   180   171

背包容量 1000

-----------------------------

最优值 9738.000000

对应重量 997.000000

线性解： 1  0  0  1  1  1  1  0  0  0  1  0  0  0  0  1  1  1  0  0  1  0  0  1  1  0  0  0  0  1  0  1  1  0  0  0  1  1  1  0  0  0  0  0  1  0  0  0  0  0  0  0  1  1  1  0  0  0  0  0

运行时间: 19297 ms






千寻～
关注
动态规划之0-1背包问题
码农也有梦
03-24 4万+
首先介绍一下动态规划... 设计一个动态规划算法，通常可按照以下几个步骤进行： (1) 找出最优解的性质，并刻画其结构特征。 (2) 递归地定义最优解的值 (3) 以自底而上的方式计算出最优值 (4) 根据计算最优值时得到的信息，构造一个最优解。 对于一个给定的问题，若具有以下两个性质，则可以考虑用动态规划法来求解。 (1) 最优子结构。如果一个问题的最优解中包含了其子问题的最优解，
C++遗传算法 解决01背包问题 注释全
03-19
本题C++代码是利用简单的遗传算法解决01背包具体问题，采用轮盘赌，最终得到最优解。
C++遗传算法 解决01背包问题（背包容量165 每个物体总量：23 31 29 44 53 38 63 85 89 82 每个物体价值92 57 49 6 60 4367 84 87 72）
桌子LZT的博客
03-19 796
C++遗传算法解决背包问题 题目： 背包容量：165 每个物品总量：23，31，29，44，53，38，63，85，89，82 每个物品价值：92，57，49，6，60，43，67，84，87，72 解决思路： 利用遗传算法，基因数组的长度就是物体数目。其0，1表示放与不放。 每个个体都有自己的基因数组，实际上每个个体就是一个解决方案，基因数组的序列就分别对应第几个物体放与不放。 杂交采用...
遗传算法解决01背包问题
03-06
本程序使用遗传算法来解决背包问题，0-1背包问题，使用C语言编写，带测试数据
遗传算法解决背包问题(C++版本)【源代码+实验报告+可执行文件】
06-02
遗传算法解决背包问题(C++版本)【源代码+实验报告+可执行文件】 人工智能实验，绝对可以运行，理由详细的注释，方便新手学习。
matlab中sobel算法_基于Matlab的遗传算法在图像分割问题中的应用
weixin_29185199的博客
01-29 278
遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。染色体作为...
遗传算法解决背包问题
01-20
本项目中，遗传算法被应用于解决经典的背包问题，这是一种典型的组合优化问题。在背包问题中，我们通常有一组物品，每件物品都有一个重量和价值，目标是在不超过背包总容量的前提下，选取物品以最大化总价值。 首先...
遗传算法01背包问题c++
12-26
遗传算法01背包问题c++
仿生智能算法实践 用 C++ 和 C语言实现遗传算法（GA） 计算TSP背包问题 全部源代码程序.rar
05-28
《仿生智能算法实践：C++与C语言实现遗传算法解决TSP与背包问题》 在计算机科学领域，优化问题的求解一直是重要的研究方向。其中，旅行商问题（Traveling Salesman Problem, TSP）和背包问题（Knapsack Problem）是...
基于C++和遗传算法解决背包问题.zip
最新发布
05-10
总结来说，利用C++和遗传算法解决背包问题，不仅体现了遗传算法在复杂优化问题上的优势，也展示了C++在算法实现上的灵活性和高效性。这种方法不仅能提供近似最优解，还能在一定程度上避免局部最优，为实际问题的解决...
基于C++的遗传算法（解决背包问题）
10-31
本程序为遗传算法程序，用于解决类似背包问题。具体要求：有32件物品，物品属性包括：价值、体积、重量三个，现有容器一个，其最大容积：80，最大允许重量：80。要求将物品装入容器，并保证价值最大化。物品属性表在附件中。
详细注解-C++遗传算法求解背包问题程序实现
04-28
遗传算法求解背包问题的C++代码及详细注解，适合新手学习。
0-1背包问题c++实现
05-09
0-1背包问题的完整c++源码 很不错的，有注释，很详细的
0-1背包问题的C++实现(动态规划)
12-20
用C++实现的0-1背包问题的动态规划解法程序。注释详实，可读性好。
遗传算法 C++实现
05-15
智能优化算法——》遗传算法——》 C++实现
遗传算法解背包问题（C++）
MaxineCaulfield的博客
12-05 1070
自用备份 #include<iostream> #include<iomanip> #include<cstdlib> #include<cmath> #include<ctime> using namespace std; //定义问题的最大规模 #define max 100 //为题规模，即共有多少个包 int packageNum; //每个包的重量 int packageWeight[max] = {5,3,11,15,7,9,13
C++实现简单遗传算法
halazi100
07-11 3004
//遗传算法 GA #include #include #include using namespace std; const int L=5; //定义编码的长度 int f(int x) //定义测设函数f(x) { int result; result=x*x*x-60*x*x+900*x+100; return result; } int main(int argc,char *a
遗传算法 01背包问题 C++
mrzzzzk的博客
10-31 4267
#include //#include #include #include #include using namespace std; const int PACK_MAX_W = 80; //背包最大承受重量 const int PACK_MAX_V = 75; //背包最大承受容积 const int NUM
c++实现01背包问题
SB202211的博客
05-19 695
话不多说，直接上代码 #include <bits/stdc++.h> using namespace std; int w[35],c[35],m,n; int dfs(int p, int x, int v) { if(p<=0||x>n) return v; if(p>=w[x]) return max(dfs(p-w[x],x+1,v+c[x]),dfs(p,x+1,v)); else return dfs(p,x+
C++实现遗传算法优化背包问题解决方案
资源摘要信息:"本资源是一份关于如何使用C++语言结合遗传算法来解决经典的背包问题的压缩文件。背包问题是一类组合优化的问题，它可以在给定的一组物品中，选择某些物品放入背包，在不超过背包的总重量或体积限制的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值